#include "cgzAFun.h"
#include "cgzCireBuffer.h"

cgzCireBuffer::cgzCireBuffer(int size)
    : m_size(size),
      m_head(0),
      m_tail(0),
      m_real(0),
      m_buffer((char*)malloc(size))
{
}

cgzCireBuffer::~cgzCireBuffer()
{
    free(m_buffer);
    m_buffer = nullptr;
}

void cgzCireBuffer::clear()
{
    m_head = 0;
    m_tail = 0;
    m_real = 0;
}

char *cgzCireBuffer::head()
{
    return m_buffer + m_head;
}

char *cgzCireBuffer::tail()
{
    return m_buffer + m_tail;
}

int cgzCireBuffer::size() const
{
    return m_size;
}

int cgzCireBuffer::left() const
{
    return m_size - m_real;
}

int cgzCireBuffer::dire() const
{
    if (m_head >= m_tail)
    {
        return m_size - m_head;
    }
    else
    {
        return m_tail - m_head;
    }
}

int cgzCireBuffer::read() const
{
    if (m_head >= m_tail)
    {
        return m_head - m_tail;
    }
    else
    {
        return m_size - m_tail;
    }
}

int cgzCireBuffer::used() const
{
    return m_real;
}

void cgzCireBuffer::push(int len)
{
    assert(len >= 0);
    m_head += len;
    if (m_head >= m_size)
    {
        m_head -= m_size; // 环形回绕
    }
    m_real += len;
    assert(m_real <= m_size);
}

void cgzCireBuffer::pop(int len)
{
    assert(len >= 0);
    m_tail += len;
    if (m_tail >= m_size)
    {
        m_tail -= m_size; // 环形回绕
    }
    m_real -= len;
    assert(m_real >= 0);
}

bool cgzCireBuffer::empty() const
{
    return 0 == used();
}

bool cgzCireBuffer::full() const
{
    return m_size == used();
}

bool cgzCireBuffer::read(std::string &str) const
{
    const int data_len = used();
    if (data_len <= 0)
    {
        return false; // 没有数据可读
    }

    // 预分配字符串空间
    str.resize(data_len);

    // 情况1：数据是连续的（未跨越缓冲区末尾）
    if (m_tail + data_len <= m_size)
    {
        str.assign(m_buffer + m_tail, data_len);
    }
    // 情况2：数据跨越缓冲区末尾
    else
    {
        const int first_part = m_size - m_tail;
        // 拷贝第一部分（到缓冲区末尾）
        str.assign(m_buffer + m_tail, first_part);
        // 拷贝第二部分（从缓冲区开头）
        str.append(m_buffer, data_len - first_part);
    }

    
    return true;
}

bool cgzCireBuffer::read(void *dst, int len) const
{
    if (len <= 0 || len > used())
    {
        return false; // 无效长度或数据不足
    }

    char *pdst = (char *)dst;
    // 情况1：数据是连续的（未跨越缓冲区末尾）
    if (m_tail + len <= m_size)
    {
        memcpy(pdst, m_buffer + m_tail, len);
    }
    // 情况2：数据跨越缓冲区末尾
    else
    {
        int first_part = m_size - m_tail;
        // 拷贝第一部分（到缓冲区末尾）
        memcpy(pdst, m_buffer + m_tail, first_part);
        // 拷贝第二部分（从缓冲区开头）
        memcpy(pdst + first_part, m_buffer, len - first_part);
    }

    return true; // 读取成功
}

bool cgzCireBuffer::read(void *dst, int len, uint8_t masking_key[4]) const
{
    if (len <= 0 || len > used())
    {
        return false; // 无效长度或数据不足
    }

    char *pdst = (char *)dst;
    // 情况1：数据是连续的（未跨越缓冲区末尾）
    if (m_tail + len <= m_size)
    {
        for (int i = 0; i < len; ++i)
        {
            pdst[i] = m_buffer[m_tail + i] ^ masking_key[i % 4];
        }
    }
    // 情况2：数据跨越缓冲区末尾
    else
    {
        int first_part = m_size - m_tail;
        // 拷贝第一部分（到缓冲区末尾）
        for (int i = 0; i < first_part; ++i)
        {
            pdst[i] = m_buffer[m_tail + i] ^ masking_key[i % 4];
        }
        // 拷贝第二部分（从缓冲区开头）
        for (int i = 0; i < len - first_part; ++i)
        {
            pdst[first_part + i] = m_buffer[i] ^ masking_key[i % 4];
        }
    }
    return true;
}

bool cgzCireBuffer::last(void *dst, int len) const
{
    if (len <= 0 || len > used())
    {
        return false; // 无效长度或数据不足
    }

    char *pdst = static_cast<char *>(dst);
    const int virtual_pos = (m_head - len + m_size) % m_size; // 计算起始位置（处理回绕）

    // 情况1：数据是连续的（未跨越缓冲区末尾）
    if (virtual_pos <= m_head)
    {
        memcpy(pdst, m_buffer + virtual_pos, len);
    }
    // 情况2：数据跨越缓冲区末尾
    else
    {
        const int first_part = m_size - virtual_pos;
        // 拷贝第一部分（从起始位置到缓冲区末尾）
        memcpy(pdst, m_buffer + virtual_pos, first_part);
        // 拷贝第二部分（从缓冲区开头）
        memcpy(pdst + first_part, m_buffer, len - first_part);
    }
    return true;
}


bool cgzCireBuffer::push(void *dst, int len)
{
    if (len <= 0 || len > left())
    {
        return false; // 无效长度或数据不足
    }
    char *pdst = (char *)dst;
    // 情况1：数据是连续的（未跨越缓冲区末尾）
    if (m_head + len <= m_size)
    {
        memcpy(m_buffer + m_head, pdst, len);
    }
    // 情况2：数据跨越缓冲区末尾
    else
    {
        int first_part = m_size - m_head;
        // 拷贝第一部分（到缓冲区末尾）
        memcpy(m_buffer + m_head, pdst, first_part);
        // 拷贝第二部分（从缓冲区开头）
        memcpy(m_buffer, pdst + first_part, len - first_part);
    }
    push(len);
    return true;
}
